diff --git a/system/database/DB.php b/system/database/DB.php
index d603805..2446645 100644
--- a/system/database/DB.php
+++ b/system/database/DB.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -29,7 +29,7 @@
 	{
 		include(APPPATH.'config/database'.EXT);
 		
-		if (! isset($db) OR count($db) == 0)
+		if ( ! isset($db) OR count($db) == 0)
 		{
 			show_error('No database connection settings were found in the database config file.');
 		}
@@ -39,7 +39,7 @@
 			$active_group = $params;
 		}
 		
-		if (! isset($active_group) OR ! isset($db[$active_group]))
+		if ( ! isset($active_group) OR ! isset($db[$active_group]))
 		{
 			show_error('You have specified an invalid database connection group.');
 		}
@@ -71,7 +71,7 @@
 	}
 	
 	// No DB specified yet?  Beat them senseless...
-	if (! isset($params['dbdriver']) OR $params['dbdriver'] == '')
+	if ( ! isset($params['dbdriver']) OR $params['dbdriver'] == '')
 	{
 		show_error('You have not selected a database type to connect to.');
 	}
@@ -88,18 +88,18 @@
 	
 	require_once(BASEPATH.'database/DB_driver'.EXT);
 
-	if (! isset($active_record) OR $active_record == TRUE)
+	if ( ! isset($active_record) OR $active_record == TRUE)
 	{
 		require_once(BASEPATH.'database/DB_active_rec'.EXT);
 		
-		if (! class_exists('CI_DB'))
+		if ( ! class_exists('CI_DB'))
 		{
 			eval('class CI_DB extends CI_DB_active_record { }');
 		}
 	}
 	else
 	{
-		if (! class_exists('CI_DB'))
+		if ( ! class_exists('CI_DB'))
 		{
 			eval('class CI_DB extends CI_DB_driver { }');
 		}
@@ -120,6 +120,6 @@
 }	
 
 
-
-/* End of file DB.php */
+
+/* End of file DB.php */
 /* Location: ./system/database/DB.php */
\ No newline at end of file
diff --git a/system/database/DB_active_rec.php b/system/database/DB_active_rec.php
index b531585..3cb3982 100644
--- a/system/database/DB_active_rec.php
+++ b/system/database/DB_active_rec.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -147,7 +147,7 @@
 	 */
 	function select_max($select = '', $alias='')
 	{
-		if (!is_string($select) || $select == '')
+		if ( ! is_string($select) OR $select == '')
 		{
 			$this->display_error('db_invalid_query');
 		}
@@ -179,7 +179,7 @@
 	 */
 	function select_min($select = '', $alias='')
 	{
-		if (!is_string($select) || $select == '')
+		if ( ! is_string($select) OR $select == '')
 		{
 			$this->display_error('db_invalid_query');
 		}
@@ -211,7 +211,7 @@
 	 */
 	function select_avg($select = '', $alias='')
 	{
-		if (!is_string($select) || $select == '')
+		if ( ! is_string($select) OR $select == '')
 		{
 			$this->display_error('db_invalid_query');
 		}
@@ -243,7 +243,7 @@
 	 */
 	function select_sum($select = '', $alias='')
 	{
-		if (!is_string($select) || $select == '')
+		if ( ! is_string($select) OR $select == '')
 		{
 			$this->display_error('db_invalid_query');
 		}
@@ -322,7 +322,7 @@
 		{
 			$type = strtoupper(trim($type));
 
-			if (! in_array($type, array('LEFT', 'RIGHT', 'OUTER', 'INNER', 'LEFT OUTER', 'RIGHT OUTER'), TRUE))
+			if ( ! in_array($type, array('LEFT', 'RIGHT', 'OUTER', 'INNER', 'LEFT OUTER', 'RIGHT OUTER'), TRUE))
 			{
 				$type = '';
 			}
@@ -418,7 +418,7 @@
 	 */
 	function _where($key, $value = NULL, $type = 'AND ', $escape = TRUE)
 	{
-		if (! is_array($key))
+		if ( ! is_array($key))
 		{
 			$key = array($key => $value);
 		}
@@ -427,13 +427,13 @@
 		{
 			$prefix = (count($this->ar_where) == 0) ? '' : $type;
 
-			if (! $this->_has_operator($k) && is_null($key[$k]))
+			if ( ! $this->_has_operator($k) && is_null($key[$k]))
 			{
 				// value appears not to have been set, assign the test to IS NULL
 				$k .= ' IS NULL';
 			}
 			
-			if (! is_null($v))
+			if ( ! is_null($v))
 			{
 
 				if ($escape === TRUE)
@@ -449,7 +449,7 @@
 					}
 				}
 
-				if (! $this->_has_operator($k))
+				if ( ! $this->_has_operator($k))
 				{
 					$k .= ' =';
 				}
@@ -570,7 +570,7 @@
 	 */
 	function _where_in($key = NULL, $values = NULL, $not = FALSE, $type = 'AND ')
 	{
-		if ($key === NULL || !is_array($values))
+		if ($key === NULL OR ! is_array($values))
 		{
 			return;
 		}
@@ -696,7 +696,7 @@
 	 */
 	function _like($field, $match = '', $type = 'AND ', $side = 'both', $not = '')
 	{
-		if (! is_array($field))
+		if ( ! is_array($field))
 		{
 			$field = array($field => $match);
 		}
@@ -838,7 +838,7 @@
 	 */
 	function _having($key, $value = '', $type = 'AND ', $escape = TRUE)
 	{
-		if (! is_array($key))
+		if ( ! is_array($key))
 		{
 			$key = array($key => $value);
 		}
@@ -978,7 +978,7 @@
 	{
 		$key = $this->_object_to_array($key);
 	
-		if (! is_array($key))
+		if ( ! is_array($key))
 		{
 			$key = array($key => $value);
 		}	
@@ -1028,7 +1028,7 @@
 			$this->from($table);
 		}
 		
-		if (! is_null($limit))
+		if ( ! is_null($limit))
 		{
 			$this->limit($limit, $offset);
 		}
@@ -1093,12 +1093,12 @@
 			$this->from($table);
 		}
 
-		if (! is_null($where))
+		if ( ! is_null($where))
 		{
 			$this->where($where);
 		}
 		
-		if (! is_null($limit))
+		if ( ! is_null($limit))
 		{
 			$this->limit($limit, $offset);
 		}
@@ -1136,7 +1136,7 @@
 	 */
 	function insert($table = '', $set = NULL)
 	{
-		if (! is_null($set))
+		if ( ! is_null($set))
 		{
 			$this->set($set);
 		}
@@ -1152,7 +1152,7 @@
 
 		if ($table == '')
 		{
-			if (! isset($this->ar_from[0]))
+			if ( ! isset($this->ar_from[0]))
 			{
 				if ($this->db_debug)
 				{
@@ -1185,7 +1185,7 @@
 	 */
 	function update($table = '', $set = NULL, $where = NULL, $limit = NULL)
 	{
-		if (! is_null($set))
+		if ( ! is_null($set))
 		{
 			$this->set($set);
 		}
@@ -1201,7 +1201,7 @@
 
 		if ($table == '')
 		{
-			if (! isset($this->ar_from[0]))
+			if ( ! isset($this->ar_from[0]))
 			{
 				if ($this->db_debug)
 				{
@@ -1244,7 +1244,7 @@
 	{
 		if ($table == '')
 		{
-			if (! isset($this->ar_from[0]))
+			if ( ! isset($this->ar_from[0]))
 			{
 				if ($this->db_debug)
 				{
@@ -1285,7 +1285,7 @@
 	{
 		if ($table == '')
 		{
-			if (! isset($this->ar_from[0]))
+			if ( ! isset($this->ar_from[0]))
 			{
 				if ($this->db_debug)
 				{
@@ -1327,7 +1327,7 @@
 	{
 		if ($table == '')
 		{
-			if (! isset($this->ar_from[0]))
+			if ( ! isset($this->ar_from[0]))
 			{
 				if ($this->db_debug)
 				{
@@ -1407,7 +1407,7 @@
 	function _has_operator($str)
 	{
 		$str = trim($str);
-		if (! preg_match("/(\s|<|>|!|=|is null|is not null)/i", $str))
+		if ( ! preg_match("/(\s|<|>|!|=|is null|is not null)/i", $str))
 		{
 			return FALSE;
 		}
@@ -1480,7 +1480,7 @@
 	{
 		$this->_merge_cache();
 
-		$sql = (! $this->ar_distinct) ? 'SELECT ' : 'SELECT DISTINCT ';
+		$sql = ( ! $this->ar_distinct) ? 'SELECT ' : 'SELECT DISTINCT ';
 	
 		$sql .= (count($this->ar_select) == 0) ? '*' : implode(', ', $this->_filter_table_aliases($this->ar_select));
 
@@ -1583,7 +1583,7 @@
 	 */
 	function _object_to_array($object)
 	{
-		if (! is_object($object))
+		if ( ! is_object($object))
 		{
 			return $object;
 		}
@@ -1592,7 +1592,7 @@
 		foreach (get_object_vars($object) as $key => $val)
 		{
 			// There are some built in keys we need to ignore for this conversion
-			if (! is_object($val) && ! is_array($val) && $key != '_parent_name' && $key != '_ci_scaffolding' && $key != '_ci_scaff_table')
+			if ( ! is_object($val) && ! is_array($val) && $key != '_parent_name' && $key != '_ci_scaffolding' && $key != '_ci_scaff_table')
   
 			{
 				$array[$key] = $val;
@@ -1696,7 +1696,7 @@
 	{
 		foreach ($ar_reset_items as $item => $default_value)
 		{
-			if (!in_array($item, $this->ar_store_array))
+			if ( ! in_array($item, $this->ar_store_array))
 			{
 				$this->$item = $default_value;
 			}
diff --git a/system/database/DB_cache.php b/system/database/DB_cache.php
index 448727f..977327a 100644
--- a/system/database/DB_cache.php
+++ b/system/database/DB_cache.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -66,7 +66,7 @@
 		// Add a trailing slash to the path if needed
 		$path = preg_replace("/(.+?)\/*$/", "\\1/",  $path);
 
-		if (! is_dir($path) OR ! is_really_writable($path))
+		if ( ! is_dir($path) OR ! is_really_writable($path))
 		{
 			// If the path is wrong we'll turn off caching
 			return $this->db->cache_off();
@@ -89,7 +89,7 @@
 	 */
 	function read($sql)
 	{
-		if (! $this->check_path())
+		if ( ! $this->check_path())
 		{
 			return $this->db->cache_off();
 		}
@@ -117,7 +117,7 @@
 	 */
 	function write($sql, $object)
 	{
-		if (! $this->check_path())
+		if ( ! $this->check_path())
 		{
 			return $this->db->cache_off();
 		}
@@ -129,9 +129,9 @@
 		
 		$filename = md5($sql);
 	
-		if (! @is_dir($dir_path))
+		if ( ! @is_dir($dir_path))
 		{
-			if (! @mkdir($dir_path, DIR_WRITE_MODE))
+			if ( ! @mkdir($dir_path, DIR_WRITE_MODE))
 			{
 				return FALSE;
 			}
diff --git a/system/database/DB_driver.php b/system/database/DB_driver.php
index 9ad235d..306f09d 100644
--- a/system/database/DB_driver.php
+++ b/system/database/DB_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -147,7 +147,7 @@
 						// In the event the DB was created we need to select it
 						if ($this->db_select())
 						{
-							if (! $this->db_set_charset($this->char_set, $this->dbcollat))
+							if ( ! $this->db_set_charset($this->char_set, $this->dbcollat))
 							{
 								log_message('error', 'Unable to set database connection charset: '.$this->char_set);
 
@@ -173,7 +173,7 @@
 				return FALSE;
 			}
 			
-			if (! $this->db_set_charset($this->char_set, $this->dbcollat))
+			if ( ! $this->db_set_charset($this->char_set, $this->dbcollat))
 			{
 				log_message('error', 'Unable to set database connection charset: '.$this->char_set);
 			
@@ -1163,7 +1163,7 @@
 		}
 		else
 		{
-			$message = (! is_array($error)) ? array(str_replace('%s', $swap, $LANG->line($error))) : $error;
+			$message = ( ! is_array($error)) ? array(str_replace('%s', $swap, $LANG->line($error))) : $error;
 		}
 		
 		$error =& load_class('Exceptions');
diff --git a/system/database/DB_forge.php b/system/database/DB_forge.php
index d7259c0..d3ef326 100644
--- a/system/database/DB_forge.php
+++ b/system/database/DB_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * Code Igniter
  *
@@ -341,6 +341,6 @@
 	}
 
 }
-
-/* End of file DB_forge.php */
+
+/* End of file DB_forge.php */
 /* Location: ./system/database/DB_forge.php */
\ No newline at end of file
diff --git a/system/database/DB_result.php b/system/database/DB_result.php
index b98d7a9..d8d0d0d 100644
--- a/system/database/DB_result.php
+++ b/system/database/DB_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -125,10 +125,10 @@
 	 */	
 	function row($n = 0, $type = 'object')
 	{
-		if (! is_numeric($n))
+		if ( ! is_numeric($n))
 		{
 			// We cache the row data for subsequent uses
-			if (! is_array($this->row_data))
+			if ( ! is_array($this->row_data))
 			{
 				$this->row_data = $this->row_array(0);
 			}
@@ -156,7 +156,7 @@
 	function set_row($key, $value = NULL)
 	{
 		// We cache the row data for subsequent uses
-		if (! is_array($this->row_data))
+		if ( ! is_array($this->row_data))
 		{
 			$this->row_data = $this->row_array(0);
 		}
@@ -338,6 +338,6 @@
 	
 }
 // END DB_result class
-
-/* End of file DB_result.php */
+
+/* End of file DB_result.php */
 /* Location: ./system/database/DB_result.php */
\ No newline at end of file
diff --git a/system/database/DB_utility.php b/system/database/DB_utility.php
index 5d4c2de..d273df1 100644
--- a/system/database/DB_utility.php
+++ b/system/database/DB_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * Code Igniter
  *
@@ -175,7 +175,7 @@
 	 */
 	function csv_from_result($query, $delim = ",", $newline = "\n", $enclosure = '"')
 	{
-		if (! is_object($query) OR ! method_exists($query, 'field_names'))
+		if ( ! is_object($query) OR ! method_exists($query, 'field_names'))
 		{
 			show_error('You must submit a valid result object');
 		}	
@@ -217,7 +217,7 @@
 	 */
 	function xml_from_result($query, $params = array())
 	{
-		if (! is_object($query) OR ! method_exists($query, 'field_names'))
+		if ( ! is_object($query) OR ! method_exists($query, 'field_names'))
 		{
 			show_error('You must submit a valid result object');
 		}
@@ -225,7 +225,7 @@
 		// Set our default values
 		foreach (array('root' => 'root', 'element' => 'element', 'newline' => "\n", 'tab' => "\t") as $key => $val)
 		{
-			if (! isset($params[$key]))
+			if ( ! isset($params[$key]))
 			{
 				$params[$key] = $val;
 			}
@@ -310,7 +310,7 @@
 		// ------------------------------------------------------
 
 		// Validate the format
-		if (! in_array($prefs['format'], array('gzip', 'zip', 'txt'), TRUE))
+		if ( ! in_array($prefs['format'], array('gzip', 'zip', 'txt'), TRUE))
 		{
 			$prefs['format'] = 'txt';
 		}
@@ -367,7 +367,7 @@
 			}
 			
 			// Tack on the ".sql" file extension if needed
-			if (! preg_match("|.+?\.sql$|", $prefs['filename']))
+			if ( ! preg_match("|.+?\.sql$|", $prefs['filename']))
 			{
 				$prefs['filename'] .= '.sql';
 			}
@@ -384,6 +384,6 @@
 
 }
 
-
-/* End of file DB_utility.php */
+
+/* End of file DB_utility.php */
 /* Location: ./system/database/DB_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/mssql/mssql_driver.php b/system/database/drivers/mssql/mssql_driver.php
index f789634..34ad979 100644
--- a/system/database/drivers/mssql/mssql_driver.php
+++ b/system/database/drivers/mssql/mssql_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -132,7 +132,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -162,7 +162,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -187,7 +187,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -492,7 +492,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -540,7 +540,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -587,7 +587,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -599,7 +599,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -641,6 +641,6 @@
 }
 
 
-
-/* End of file mssql_driver.php */
+
+/* End of file mssql_driver.php */
 /* Location: ./system/database/drivers/mssql/mssql_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/mssql/mssql_forge.php b/system/database/drivers/mssql/mssql_forge.php
index d42fd5e..ddd1bb6 100644
--- a/system/database/drivers/mssql/mssql_forge.php
+++ b/system/database/drivers/mssql/mssql_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -235,6 +235,6 @@
 	}
 
 }
-
-/* End of file mssql_forge.php */
+
+/* End of file mssql_forge.php */
 /* Location: ./system/database/drivers/mssql/mssql_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/mssql/mssql_result.php b/system/database/drivers/mssql/mssql_result.php
index fded4cf..7532d20 100644
--- a/system/database/drivers/mssql/mssql_result.php
+++ b/system/database/drivers/mssql/mssql_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -170,6 +170,6 @@
 
 }
 
-
-/* End of file mssql_result.php */
+
+/* End of file mssql_result.php */
 /* Location: ./system/database/drivers/mssql/mssql_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/mssql/mssql_utility.php b/system/database/drivers/mssql/mssql_utility.php
index 75a8fb4..c62146b 100644
--- a/system/database/drivers/mssql/mssql_utility.php
+++ b/system/database/drivers/mssql/mssql_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -118,6 +118,6 @@
 
 }
 
-
-/* End of file mssql_utility.php */
+
+/* End of file mssql_utility.php */
 /* Location: ./system/database/drivers/mssql/mssql_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysql/mysql_driver.php b/system/database/drivers/mysql/mysql_driver.php
index 397af02..8df6c1b 100644
--- a/system/database/drivers/mysql/mysql_driver.php
+++ b/system/database/drivers/mysql/mysql_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -161,7 +161,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -192,7 +192,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -218,7 +218,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -495,7 +495,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -543,7 +543,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -589,7 +589,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -601,7 +601,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -649,6 +649,6 @@
 	
 }
 
-
-/* End of file mysql_driver.php */
+
+/* End of file mysql_driver.php */
 /* Location: ./system/database/drivers/mysql/mysql_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysql/mysql_forge.php b/system/database/drivers/mysql/mysql_forge.php
index 6701c42..a631e43 100644
--- a/system/database/drivers/mysql/mysql_forge.php
+++ b/system/database/drivers/mysql/mysql_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -238,6 +238,6 @@
 	}
 
 }
-
-/* End of file mysql_forge.php */
+
+/* End of file mysql_forge.php */
 /* Location: ./system/database/drivers/mysql/mysql_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysql/mysql_result.php b/system/database/drivers/mysql/mysql_result.php
index 01b57e1..4d9dd82 100644
--- a/system/database/drivers/mysql/mysql_result.php
+++ b/system/database/drivers/mysql/mysql_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -170,6 +170,6 @@
 	
 }
 
-
-/* End of file mysql_result.php */
+
+/* End of file mysql_result.php */
 /* Location: ./system/database/drivers/mysql/mysql_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysql/mysql_utility.php b/system/database/drivers/mysql/mysql_utility.php
index 0804f29..6bae527 100644
--- a/system/database/drivers/mysql/mysql_utility.php
+++ b/system/database/drivers/mysql/mysql_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -249,6 +249,6 @@
 	}
 
 }
-
-/* End of file mysql_utility.php */
+
+/* End of file mysql_utility.php */
 /* Location: ./system/database/drivers/mysql/mysql_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysqli/mysqli_driver.php b/system/database/drivers/mysqli/mysqli_driver.php
index c993e33..4e840e7 100644
--- a/system/database/drivers/mysqli/mysqli_driver.php
+++ b/system/database/drivers/mysqli/mysqli_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -164,7 +164,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -195,7 +195,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -221,7 +221,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -491,7 +491,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -539,7 +539,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -586,7 +586,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -598,7 +598,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -645,6 +645,6 @@
 
 }
 
-
-/* End of file mysqli_driver.php */
+
+/* End of file mysqli_driver.php */
 /* Location: ./system/database/drivers/mysqli/mysqli_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysqli/mysqli_forge.php b/system/database/drivers/mysqli/mysqli_forge.php
index 087f9b8..f767acb 100644
--- a/system/database/drivers/mysqli/mysqli_forge.php
+++ b/system/database/drivers/mysqli/mysqli_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -238,6 +238,6 @@
 	}
 
 }
-
-/* End of file mysqli_forge.php */
+
+/* End of file mysqli_forge.php */
 /* Location: ./system/database/drivers/mysqli/mysqli_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysqli/mysqli_result.php b/system/database/drivers/mysqli/mysqli_result.php
index 6b42d35..4b8115d 100644
--- a/system/database/drivers/mysqli/mysqli_result.php
+++ b/system/database/drivers/mysqli/mysqli_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -170,6 +170,6 @@
 	
 }
 
-
-/* End of file mysqli_result.php */
+
+/* End of file mysqli_result.php */
 /* Location: ./system/database/drivers/mysqli/mysqli_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/mysqli/mysqli_utility.php b/system/database/drivers/mysqli/mysqli_utility.php
index 24b05b7..235ee4b 100644
--- a/system/database/drivers/mysqli/mysqli_utility.php
+++ b/system/database/drivers/mysqli/mysqli_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -118,6 +118,6 @@
 	}
 
 }
-
-/* End of file mysqli_utility.php */
+
+/* End of file mysqli_utility.php */
 /* Location: ./system/database/drivers/mysqli/mysqli_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/oci8/oci8_driver.php b/system/database/drivers/oci8/oci8_driver.php
index 3670959..2bc4525 100644
--- a/system/database/drivers/oci8/oci8_driver.php
+++ b/system/database/drivers/oci8/oci8_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -155,7 +155,7 @@
 	 */
 	function _set_stmt_id($sql)
 	{
-		if (! is_resource($this->stmt_id))
+		if ( ! is_resource($this->stmt_id))
 		{
 			$this->stmt_id = ociparse($this->conn_id, $this->_prep_query($sql));
 		}
@@ -254,7 +254,7 @@
 	 */
 	function _bind_params($params)
 	{
-		if (! is_array($params) OR ! is_resource($this->stmt_id))
+		if ( ! is_array($params) OR ! is_resource($this->stmt_id))
 		{
 			return;
 		}
@@ -263,7 +263,7 @@
 		{
  			foreach (array('name', 'value', 'type', 'length') as $val)
 			{
-				if (! isset($param[$val]))
+				if ( ! isset($param[$val]))
 				{
 					$param[$val] = '';
 				}
@@ -283,7 +283,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -313,7 +313,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -339,7 +339,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -603,7 +603,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -651,7 +651,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -697,7 +697,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -709,7 +709,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -761,6 +761,6 @@
 }
 
 
-
-/* End of file oci8_driver.php */
+
+/* End of file oci8_driver.php */
 /* Location: ./system/database/drivers/oci8/oci8_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/oci8/oci8_forge.php b/system/database/drivers/oci8/oci8_forge.php
index 64dd2a2..9f3fac5 100644
--- a/system/database/drivers/oci8/oci8_forge.php
+++ b/system/database/drivers/oci8/oci8_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -232,6 +232,6 @@
 
 
 }
-
-/* End of file oci8_forge.php */
+
+/* End of file oci8_forge.php */
 /* Location: ./system/database/drivers/oci8/oci8_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/oci8/oci8_result.php b/system/database/drivers/oci8/oci8_result.php
index 416c57d..73373c8 100644
--- a/system/database/drivers/oci8/oci8_result.php
+++ b/system/database/drivers/oci8/oci8_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -248,6 +248,6 @@
 
 }
 
-
-/* End of file oci8_result.php */
+
+/* End of file oci8_result.php */
 /* Location: ./system/database/drivers/oci8/oci8_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/oci8/oci8_utility.php b/system/database/drivers/oci8/oci8_utility.php
index 93eaa22..69d07f4 100644
--- a/system/database/drivers/oci8/oci8_utility.php
+++ b/system/database/drivers/oci8/oci8_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -117,6 +117,6 @@
 	}
 
 }
-
-/* End of file oci8_utility.php */
+
+/* End of file oci8_utility.php */
 /* Location: ./system/database/drivers/oci8/oci8_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/odbc/odbc_driver.php b/system/database/drivers/odbc/odbc_driver.php
index 4511592..48a1432 100644
--- a/system/database/drivers/odbc/odbc_driver.php
+++ b/system/database/drivers/odbc/odbc_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -152,7 +152,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -181,7 +181,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -207,7 +207,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -464,7 +464,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -512,7 +512,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -559,7 +559,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -571,7 +571,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -613,6 +613,6 @@
 }
 
 
-
-/* End of file odbc_driver.php */
+
+/* End of file odbc_driver.php */
 /* Location: ./system/database/drivers/odbc/odbc_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/odbc/odbc_forge.php b/system/database/drivers/odbc/odbc_forge.php
index fb011f2..60df616 100644
--- a/system/database/drivers/odbc/odbc_forge.php
+++ b/system/database/drivers/odbc/odbc_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -253,6 +253,6 @@
 
 
 }
-
-/* End of file odbc_forge.php */
+
+/* End of file odbc_forge.php */
 /* Location: ./system/database/drivers/odbc/odbc_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/odbc/odbc_result.php b/system/database/drivers/odbc/odbc_result.php
index 4acfb05..809887a 100644
--- a/system/database/drivers/odbc/odbc_result.php
+++ b/system/database/drivers/odbc/odbc_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -229,6 +229,6 @@
 
 }
 
-
-/* End of file odbc_result.php */
+
+/* End of file odbc_result.php */
 /* Location: ./system/database/drivers/odbc/odbc_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/odbc/odbc_utility.php b/system/database/drivers/odbc/odbc_utility.php
index ac8b5d8..5d90105 100644
--- a/system/database/drivers/odbc/odbc_utility.php
+++ b/system/database/drivers/odbc/odbc_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -143,6 +143,6 @@
 		return FALSE;
 	}
 }
-
-/* End of file odbc_utility.php */
+
+/* End of file odbc_utility.php */
 /* Location: ./system/database/drivers/odbc/odbc_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/postgre/postgre_driver.php b/system/database/drivers/postgre/postgre_driver.php
index 4fd92f0..9a260a5 100644
--- a/system/database/drivers/postgre/postgre_driver.php
+++ b/system/database/drivers/postgre/postgre_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -150,7 +150,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -179,7 +179,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -203,7 +203,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -488,7 +488,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -536,7 +536,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -583,7 +583,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -595,7 +595,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -641,6 +641,6 @@
 
 }
 
-
-/* End of file postgre_driver.php */
+
+/* End of file postgre_driver.php */
 /* Location: ./system/database/drivers/postgre/postgre_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/postgre/postgre_forge.php b/system/database/drivers/postgre/postgre_forge.php
index fb4fcf1..f8dfca8 100644
--- a/system/database/drivers/postgre/postgre_forge.php
+++ b/system/database/drivers/postgre/postgre_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -235,6 +235,6 @@
 
 
 }
-
-/* End of file postgre_forge.php */
+
+/* End of file postgre_forge.php */
 /* Location: ./system/database/drivers/postgre/postgre_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/postgre/postgre_result.php b/system/database/drivers/postgre/postgre_result.php
index 25360b3..1613da9 100644
--- a/system/database/drivers/postgre/postgre_result.php
+++ b/system/database/drivers/postgre/postgre_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -170,6 +170,6 @@
 	
 }
 
-
-/* End of file postgre_result.php */
+
+/* End of file postgre_result.php */
 /* Location: ./system/database/drivers/postgre/postgre_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/postgre/postgre_utility.php b/system/database/drivers/postgre/postgre_utility.php
index 17df599..261050b 100644
--- a/system/database/drivers/postgre/postgre_utility.php
+++ b/system/database/drivers/postgre/postgre_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -119,6 +119,6 @@
 
 }
 
-
-/* End of file postgre_utility.php */
+
+/* End of file postgre_utility.php */
 /* Location: ./system/database/drivers/postgre/postgre_utility.php */
\ No newline at end of file
diff --git a/system/database/drivers/sqlite/sqlite_driver.php b/system/database/drivers/sqlite/sqlite_driver.php
index cb53ad9..b323e41 100644
--- a/system/database/drivers/sqlite/sqlite_driver.php
+++ b/system/database/drivers/sqlite/sqlite_driver.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -48,7 +48,7 @@
 	 */	
 	function db_connect()
 	{
-		if (! $conn_id = @sqlite_open($this->database, FILE_WRITE_MODE, $error))
+		if ( ! $conn_id = @sqlite_open($this->database, FILE_WRITE_MODE, $error))
 		{
 			log_message('error', $error);
 			
@@ -73,7 +73,7 @@
 	 */	
 	function db_pconnect()
 	{
-		if (! $conn_id = @sqlite_popen($this->database, FILE_WRITE_MODE, $error))
+		if ( ! $conn_id = @sqlite_popen($this->database, FILE_WRITE_MODE, $error))
 		{
 			log_message('error', $error);
 			
@@ -171,7 +171,7 @@
 	 */	
 	function trans_begin($test_mode = FALSE)
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -201,7 +201,7 @@
 	 */	
 	function trans_commit()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -226,7 +226,7 @@
 	 */	
 	function trans_rollback()
 	{
-		if (! $this->trans_enabled)
+		if ( ! $this->trans_enabled)
 		{
 			return TRUE;
 		}
@@ -482,7 +482,7 @@
 	 */
 	function _from_tables($tables)
 	{
-		if (! is_array($tables))
+		if ( ! is_array($tables))
 		{
 			$tables = array($tables);
 		}
@@ -530,7 +530,7 @@
 			$valstr[] = $key." = ".$val;
 		}
 		
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 		
 		$orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 	
@@ -577,7 +577,7 @@
 	{
 		$conditions = '';
 
-		if (count($where) > 0 || count($like) > 0)
+		if (count($where) > 0 OR count($like) > 0)
 		{
 			$conditions = "\nWHERE ";
 			$conditions .= implode("\n", $this->ar_where);
@@ -589,7 +589,7 @@
 			$conditions .= implode("\n", $like);
 		}
 
-		$limit = (!$limit) ? '' : ' LIMIT '.$limit;
+		$limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 	
 		return "DELETE FROM ".$table.$conditions.$limit;
 	}
@@ -656,6 +656,6 @@
 
 }
 
-
-/* End of file sqlite_driver.php */
+
+/* End of file sqlite_driver.php */
 /* Location: ./system/database/drivers/sqlite/sqlite_driver.php */
\ No newline at end of file
diff --git a/system/database/drivers/sqlite/sqlite_forge.php b/system/database/drivers/sqlite/sqlite_forge.php
index 8a1a4da..25c74a7 100644
--- a/system/database/drivers/sqlite/sqlite_forge.php
+++ b/system/database/drivers/sqlite/sqlite_forge.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -49,7 +49,7 @@
 	 */
 	function _drop_database($name)
 	{
-		if (! @file_exists($this->db->database) OR ! @unlink($this->db->database))
+		if ( ! @file_exists($this->db->database) OR ! @unlink($this->db->database))
 		{
 			if ($this->db->db_debug)
 			{
@@ -231,6 +231,6 @@
 		
 	}
 }
-
-/* End of file sqlite_forge.php */
+
+/* End of file sqlite_forge.php */
 /* Location: ./system/database/drivers/sqlite/sqlite_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/sqlite/sqlite_result.php b/system/database/drivers/sqlite/sqlite_result.php
index 72c93fd..8bb0d9d 100644
--- a/system/database/drivers/sqlite/sqlite_result.php
+++ b/system/database/drivers/sqlite/sqlite_result.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -180,6 +180,6 @@
 
 }
 
-
-/* End of file sqlite_result.php */
+
+/* End of file sqlite_result.php */
 /* Location: ./system/database/drivers/sqlite/sqlite_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/sqlite/sqlite_utility.php b/system/database/drivers/sqlite/sqlite_utility.php
index c85e365..fff24a7 100644
--- a/system/database/drivers/sqlite/sqlite_utility.php
+++ b/system/database/drivers/sqlite/sqlite_utility.php
@@ -1,4 +1,4 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
@@ -124,7 +124,7 @@
 	 */
 	function _drop_database($name)
 	{
-		if (! @file_exists($this->db->database) OR ! @unlink($this->db->database))
+		if ( ! @file_exists($this->db->database) OR ! @unlink($this->db->database))
 		{
 			if ($this->db->db_debug)
 			{
@@ -136,6 +136,6 @@
 	}
 
 }
-
-/* End of file sqlite_utility.php */
+
+/* End of file sqlite_utility.php */
 /* Location: ./system/database/drivers/sqlite/sqlite_utility.php */
\ No newline at end of file
